<?php
    // +----------------------------------------------------------------------
    // | ThinkPHP [ WE CAN DO IT JUST THINK ]
    // +----------------------------------------------------------------------
    // | Copyright (c) 2006~2017 http://thinkphp.cn All rights reserved.
    // +----------------------------------------------------------------------
    // | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
    // +----------------------------------------------------------------------
    // | Author: liu21st <liu21st@gmail.com>
    // +----------------------------------------------------------------------
    namespace think;

    use think\exception\ClassNotFoundException;

    class Validate {
        // 实例
        protected static $instance;
        // 自定义的验证类型
        protected static $type = [];
        // 验证类型别名
        protected static $typeMsg = [
            'require'     => ':attribute不能为空',
            'number'      => ':attribute必须是数字',
            'float'       => ':attribute必须是浮点数',
            'boolean'     => ':attribute必须是布尔值',
            'email'       => ':attribute格式不符',
            'array'       => ':attribute必须是数组',
            'accepted'    => ':attribute必须是yes、on或者1',
            'date'        => ':attribute格式不符合',
            'file'        => ':attribute不是有效的上传文件',
            'image'       => ':attribute不是有效的图像文件',
            'alpha'       => ':attribute只能是字母',
            'alphaNum'    => ':attribute只能是字母和数字',
            'alphaDash'   => ':attribute只能是字母、数字和下划线_及破折号-',
            'activeUrl'   => ':attribute不是有效的域名或者IP',
            'chs'         => ':attribute只能是汉字',
            'chsAlpha'    => ':attribute只能是汉字、字母',
            'chsAlphaNum' => ':attribute只能是汉字、字母和数字',
            'chsDash'     => ':attribute只能是汉字、字母、数字和下划线_及破折号-',
            'url'         => ':attribute不是有效的URL地址',
            'ip'          => ':attribute不是有效的IP地址',
            'dateFormat'  => ':attribute必须使用日期格式 :rule',
            'in'          => ':attribute必须在 :rule 范围内',
            'notIn'       => ':attribute不能在 :rule 范围内',
            'between'     => ':attribute只能在 :1 - :2 之间',
            'notBetween'  => ':attribute不能在 :1 - :2 之间',
            'length'      => ':attribute长度不符合要求 :rule',
            'max'         => ':attribute长度不能超过 :rule',
            'min'         => ':attribute长度不能小于 :rule',
            'after'       => ':attribute日期不能小于 :rule',
            'before'      => ':attribute日期不能超过 :rule',
            'expire'      => '不在有效期内 :rule',
            'allowIp'     => '不允许的IP访问',
            'denyIp'      => '禁止的IP访问',
            'confirm'     => ':attribute和确认字段:2不一致',
            'different'   => ':attribute和比较字段:2不能相同',
            'egt'         => ':attribute必须大于等于 :rule',
            'gt'          => ':attribute必须大于 :rule',
            'elt'         => ':attribute必须小于等于 :rule',
            'lt'          => ':attribute必须小于 :rule',
            'eq'          => ':attribute必须等于 :rule',
            'unique'      => ':attribute已存在',
            'regex'       => ':attribute不符合指定规则',
            'method'      => '无效的请求类型',
            'token'       => '令牌数据无效',
            'fileSize'    => '上传文件大小不符',
            'fileExt'     => '上传文件后缀不符',
            'fileMime'    => '上传文件类型不符',
        ];
        // 当前验证的规则
        protected $alias = [
            '>'    => 'gt',
            '>='   => 'egt',
            '<'    => 'lt',
            '<='   => 'elt',
            '='    => 'eq',
            'same' => 'eq',
        ];
        // 验证提示信息
        protected $rule = [];
        // 验证字段描述
        protected $message = [];
        // 验证规则默认提示信息
        protected $field = [];
        // 当前验证场景
        protected $currentScene = null;
        // 正则表达式 regex = ['zip'=>'\d{6}',...]
        protected $regex = [];
        // 验证场景 scene = ['edit'=>'name1,name2,...']
        protected $scene = [];
        // 验证失败错误信息
        protected $error = [];
        // 批量验证
        protected $batch = false;

        /**
         * 构造函数
         * @access public
         * @param array $rules   验证规则
         * @param array $message 验证提示信息
         * @param array $field   验证字段描述信息
         */
        public function __construct(array $rules = [], $message = [], $field = []) {
            $this->rule    = array_merge($this->rule, $rules);
            $this->message = array_merge($this->message, $message);
            $this->field   = array_merge($this->field, $field);
        }

        /**
         * 注册验证（类型）规则
         * @access public
         * @param string $type     验证规则类型
         * @param mixed  $callback callback方法(或闭包)
         * @return void
         */
        public static function extend($type, $callback = null) {
            if (is_array($type)) {
                self::$type = array_merge(self::$type, $type);
            } else {
                self::$type[$type] = $callback;
            }
        }

        /**
         * 获取验证规则的默认提示信息
         * @access protected
         * @param string|array $type 验证规则类型名称或者数组
         * @param string       $msg  验证提示信息
         * @return void
         */
        public static function setTypeMsg($type, $msg = null) {
            if (is_array($type)) {
                self::$typeMsg = array_merge(self::$typeMsg, $type);
            } else {
                self::$typeMsg[$type] = $msg;
            }
        }

        public static function __callStatic($method, $params) {
            $class = self::make();
            if (method_exists($class, $method)) {
                return call_user_func_array([
                                                $class,
                                                $method
                                            ], $params
                );
            } else {
                throw new \BadMethodCallException('method not exists:' . __CLASS__ . '->' . $method);
            }
        }

        /**
         * 实例化验证
         * @access public
         * @param array $rules   验证规则
         * @param array $message 验证提示信息
         * @param array $field   验证字段描述信息
         * @return Validate
         */
        public static function make($rules = [], $message = [], $field = []) {
            if (is_null(self::$instance)) {
                self::$instance = new self($rules, $message, $field);
            }
            return self::$instance;
        }

        /**
         * 添加字段验证规则
         * @access protected
         * @param string|array $name 字段名称或者规则数组
         * @param mixed        $rule 验证规则
         * @return Validate
         */
        public function rule($name, $rule = '') {
            if (is_array($name)) {
                $this->rule = array_merge($this->rule, $name);
            } else {
                $this->rule[$name] = $rule;
            }
            return $this;
        }

        /**
         * 设置提示信息
         * @access public
         * @param string|array $name    字段名称
         * @param string       $message 提示信息
         * @return Validate
         */
        public function message($name, $message = '') {
            if (is_array($name)) {
                $this->message = array_merge($this->message, $name);
            } else {
                $this->message[$name] = $message;
            }
            return $this;
        }

        /**
         * 设置验证场景
         * @access public
         * @param string|array $name   场景名或者场景设置数组
         * @param mixed        $fields 要验证的字段
         * @return Validate
         */
        public function scene($name, $fields = null) {
            if (is_array($name)) {
                $this->scene = array_merge($this->scene, $name);
            }
            if (is_null($fields)) {
                // 设置当前场景
                $this->currentScene = $name;
            } else {
                // 设置验证场景
                $this->scene[$name] = $fields;
            }
            return $this;
        }

        /**
         * 判断是否存在某个验证场景
         * @access public
         * @param string $name 场景名
         * @return bool
         */
        public function hasScene($name) {
            return isset($this->scene[$name]);
        }

        /**
         * 设置批量验证
         * @access public
         * @param bool $batch 是否批量验证
         * @return Validate
         */
        public function batch($batch = true) {
            $this->batch = $batch;
            return $this;
        }

        /**
         * 数据自动验证
         * @access public
         * @param array  $data  数据
         * @param mixed  $rules 验证规则
         * @param string $scene 验证场景
         * @return bool
         */
        public function check($data, $rules = [], $scene = '') {
            $this->error = [];
            if (empty($rules)) {
                // 读取验证规则
                $rules = $this->rule;
            }
            // 分析验证规则
            $scene = $this->getScene($scene);
            if (is_array($scene)) {
                // 处理场景验证字段
                $change = [];
                $array  = [];
                foreach ($scene as $k => $val) {
                    if (is_numeric($k)) {
                        $array[] = $val;
                    } else {
                        $array[]    = $k;
                        $change[$k] = $val;
                    }
                }
            }
            foreach ($rules as $key => $item) {
                // field => rule1|rule2... field=>['rule1','rule2',...]
                if (is_numeric($key)) {
                    // [field,rule1|rule2,msg1|msg2]
                    $key  = $item[0];
                    $rule = $item[1];
                    if (isset($item[2])) {
                        $msg = is_string($item[2]) ? explode('|', $item[2]) : $item[2];
                    } else {
                        $msg = [];
                    }
                } else {
                    $rule = $item;
                    $msg  = [];
                }
                if (strpos($key, '|')) {
                    // 字段|描述 用于指定属性名称
                    list($key, $title) = explode('|', $key);
                } else {
                    $title = isset($this->field[$key]) ? $this->field[$key] : $key;
                }
                // 场景检测
                if (!empty($scene)) {
                    if ($scene instanceof \Closure && !call_user_func_array($scene, [
                                                                                      $key,
                                                                                      $data
                                                                                  ]
                        )
                    ) {
                        continue;
                    } elseif (is_array($scene)) {
                        if (!in_array($key, $array)) {
                            continue;
                        } elseif (isset($change[$key])) {
                            // 重载某个验证规则
                            $rule = $change[$key];
                        }
                    }
                }
                // 获取数据 支持二维数组
                $value = $this->getDataValue($data, $key);
                // 字段验证
                if ($rule instanceof \Closure) {
                    // 匿名函数验证 支持传入当前字段和所有字段两个数据
                    $result = call_user_func_array($rule, [
                                                            $value,
                                                            $data
                                                        ]
                    );
                } else {
                    $result = $this->checkItem($key, $value, $rule, $data, $title, $msg);
                }
                if (true !== $result) {
                    // 没有返回true 则表示验证失败
                    if (!empty($this->batch)) {
                        // 批量验证
                        if (is_array($result)) {
                            $this->error = array_merge($this->error, $result);
                        } else {
                            $this->error[$key] = $result;
                        }
                    } else {
                        $this->error = $result;
                        return false;
                    }
                }
            }
            return !empty($this->error) ? false : true;
        }

        /**
         * 获取数据验证的场景
         * @access protected
         * @param string $scene 验证场景
         * @return array
         */
        protected function getScene($scene = '') {
            if (empty($scene)) {
                // 读取指定场景
                $scene = $this->currentScene;
            }
            if (!empty($scene) && isset($this->scene[$scene])) {
                // 如果设置了验证适用场景
                $scene = $this->scene[$scene];
                if (is_string($scene)) {
                    $scene = explode(',', $scene);
                }
            } else {
                $scene = [];
            }
            return $scene;
        }

        /**
         * 获取数据值
         * @access protected
         * @param array  $data 数据
         * @param string $key  数据标识 支持二维
         * @return mixed
         */
        protected function getDataValue($data, $key) {
            if (is_numeric($key)) {
                $value = $key;
            } elseif (strpos($key, '.')) {
                // 支持二维数组验证
                list($name1, $name2) = explode('.', $key);
                $value = isset($data[$name1][$name2]) ? $data[$name1][$name2] : null;
            } else {
                $value = isset($data[$key]) ? $data[$key] : null;
            }
            return $value;
        }

        /**
         * 验证单个字段规则
         * @access protected
         * @param string $field 字段名
         * @param mixed  $value 字段值
         * @param mixed  $rules 验证规则
         * @param array  $data  数据
         * @param string $title 字段描述
         * @param array  $msg   提示信息
         * @return mixed
         */
        protected function checkItem($field, $value, $rules, $data, $title = '', $msg = []) {
            // 支持多规则验证 require|in:a,b,c|... 或者 ['require','in'=>'a,b,c',...]
            if (is_string($rules)) {
                $rules = explode('|', $rules);
            }
            $i = 0;
            foreach ($rules as $key => $rule) {
                if ($rule instanceof \Closure) {
                    $result = call_user_func_array($rule, [
                                                            $value,
                                                            $data
                                                        ]
                    );
                    $info   = is_numeric($key) ? '' : $key;
                } else {
                    // 判断验证类型
                    if (is_numeric($key)) {
                        if (strpos($rule, ':')) {
                            list($type, $rule) = explode(':', $rule, 2);
                            if (isset($this->alias[$type])) {
                                // 判断别名
                                $type = $this->alias[$type];
                            }
                            $info = $type;
                        } elseif (method_exists($this, $rule)) {
                            $type = $rule;
                            $info = $rule;
                            $rule = '';
                        } else {
                            $type = 'is';
                            $info = $rule;
                        }
                    } else {
                        $info = $type = $key;
                    }
                    // 如果不是require 有数据才会行验证
                    if (0 === strpos($info, 'require') || (!is_null($value) && '' !== $value)) {
                        // 验证类型
                        $callback = isset(self::$type[$type]) ? self::$type[$type] : [
                            $this,
                            $type
                        ];
                        // 验证数据
                        $result = call_user_func_array($callback, [
                                                                    $value,
                                                                    $rule,
                                                                    $data,
                                                                    $field,
                                                                    $title
                                                                ]
                        );
                    } else {
                        $result = true;
                    }
                }
                if (false === $result) {
                    // 验证失败 返回错误信息
                    if (isset($msg[$i])) {
                        $message = $msg[$i];
                        if (is_string($message) && strpos($message, '{%') === 0) {
                            $message = Lang::get(substr($message, 2, -1));
                        }
                    } else {
                        $message = $this->getRuleMsg($field, $title, $info, $rule);
                    }
                    return $message;
                } elseif (true !== $result) {
                    // 返回自定义错误信息
                    if (is_string($result) && false !== strpos($result, ':')) {
                        $result = str_replace([
                                                  ':attribute',
                                                  ':rule'
                                              ], [
                                                  $title,
                                                  (string)$rule
                                              ], $result
                        );
                    }
                    return $result;
                }
                $i++;
            }
            return $result;
        }

        /**
         * 获取验证规则的错误提示信息
         * @access protected
         * @param string $attribute 字段英文名
         * @param string $title     字段描述名
         * @param string $type      验证规则名称
         * @param mixed  $rule      验证规则数据
         * @return string
         */
        protected function getRuleMsg($attribute, $title, $type, $rule) {
            if (isset($this->message[$attribute . '.' . $type])) {
                $msg = $this->message[$attribute . '.' . $type];
            } elseif (isset($this->message[$attribute][$type])) {
                $msg = $this->message[$attribute][$type];
            } elseif (isset($this->message[$attribute])) {
                $msg = $this->message[$attribute];
            } elseif (isset(self::$typeMsg[$type])) {
                $msg = self::$typeMsg[$type];
            } else {
                $msg = $title . '规则错误';
            }
            if (is_string($msg) && 0 === strpos($msg, '{%')) {
                $msg = Lang::get(substr($msg, 2, -1));
            }
            if (is_string($msg) && is_scalar($rule) && false !== strpos($msg, ':')) {
                // 变量替换
                if (is_string($rule) && strpos($rule, ',')) {
                    $array = array_pad(explode(',', $rule), 3, '');
                } else {
                    $array = array_pad([], 3, '');
                }
                $msg = str_replace([
                                       ':attribute',
                                       ':rule',
                                       ':1',
                                       ':2',
                                       ':3'
                                   ], [
                                       $title,
                                       (string)$rule,
                                       $array[0],
                                       $array[1],
                                       $array[2]
                                   ], $msg
                );
            }
            return $msg;
        }

        public function getError() {
            return $this->error;
        }

        /**
         * 验证是否和某个字段的值一致
         * @access protected
         * @param mixed  $value 字段值
         * @param mixed  $rule  验证规则
         * @param array  $data  数据
         * @param string $field 字段名
         * @return bool
         */
        protected function confirm($value, $rule, $data, $field = '') {
            if ('' == $rule) {
                if (strpos($field, '_confirm')) {
                    $rule = strstr($field, '_confirm', true);
                } else {
                    $rule = $field . '_confirm';
                }
            }
            return $this->getDataValue($data, $rule) === $value;
        }

        /**
         * 验证是否和某个字段的值是否不同
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function different($value, $rule, $data) {
            return $this->getDataValue($data, $rule) != $value;
        }

        /**
         * 验证是否大于等于某个值
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function egt($value, $rule, $data) {
            $val = $this->getDataValue($data, $rule);
            return !is_null($val) && $value >= $val;
        }

        // 判断图像类型

        /**
         * 验证是否大于某个值
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function gt($value, $rule, $data) {
            $val = $this->getDataValue($data, $rule);
            return !is_null($val) && $value > $val;
        }

        /**
         * 验证是否小于等于某个值
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function elt($value, $rule, $data) {
            $val = $this->getDataValue($data, $rule);
            return !is_null($val) && $value <= $val;
        }

        /**
         * 验证是否小于某个值
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function lt($value, $rule, $data) {
            $val = $this->getDataValue($data, $rule);
            return !is_null($val) && $value < $val;
        }

        /**
         * 验证是否等于某个值
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function eq($value, $rule) {
            return $value == $rule;
        }

        /**
         * 验证字段值是否为有效格式
         * @access protected
         * @param mixed  $value 字段值
         * @param string $rule  验证规则
         * @param array  $data  验证数据
         * @return bool
         */
        protected function is($value, $rule, $data = []) {
            switch ($rule) {
                case 'require':
                    // 必须
                    $result = !empty($value) || '0' == $value;
                    break;
                case 'accepted':
                    // 接受
                    $result = in_array($value, [
                                                 '1',
                                                 'on',
                                                 'yes'
                                             ]
                    );
                    break;
                case 'date':
                    // 是否是一个有效日期
                    $result = false !== strtotime($value);
                    break;
                case 'alpha':
                    // 只允许字母
                    $result = $this->regex($value, '/^[A-Za-z]+$/');
                    break;
                case 'alphaNum':
                    // 只允许字母和数字
                    $result = $this->regex($value, '/^[A-Za-z0-9]+$/');
                    break;
                case 'alphaDash':
                    // 只允许字母、数字和下划线 破折号
                    $result = $this->regex($value, '/^[A-Za-z0-9\-\_]+$/');
                    break;
                case 'chs':
                    // 只允许汉字
                    $result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}]+$/u');
                    break;
                case 'chsAlpha':
                    // 只允许汉字、字母
                    $result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z]+$/u');
                    break;
                case 'chsAlphaNum':
                    // 只允许汉字、字母和数字
                    $result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z0-9]+$/u');
                    break;
                case 'chsDash':
                    // 只允许汉字、字母、数字和下划线_及破折号-
                    $result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z0-9\_\-]+$/u');
                    break;
                case 'activeUrl':
                    // 是否为有效的网址
                    $result = checkdnsrr($value);
                    break;
                case 'ip':
                    // 是否为IP地址
                    $result = $this->filter($value, [
                                                      FILTER_VALIDATE_IP,
                                                      FILTER_FLAG_IPV4 | FILTER_FLAG_IPV6
                                                  ]
                    );
                    break;
                case 'url':
                    // 是否为一个URL地址
                    $result = $this->filter($value, FILTER_VALIDATE_URL);
                    break;
                case 'float':
                    // 是否为float
                    $result = $this->filter($value, FILTER_VALIDATE_FLOAT);
                    break;
                case 'number':
                    $result = is_numeric($value);
                    break;
                case 'integer':
                    // 是否为整型
                    $result = $this->filter($value, FILTER_VALIDATE_INT);
                    break;
                case 'email':
                    // 是否为邮箱地址
                    $result = $this->filter($value, FILTER_VALIDATE_EMAIL);
                    break;
                case 'boolean':
                    // 是否为布尔值
                    $result = in_array($value, [
                        true,
                        false,
                        0,
                        1,
                        '0',
                        '1'
                    ], true
                    );
                    break;
                case 'array':
                    // 是否为数组
                    $result = is_array($value);
                    break;
                case 'file':
                    $result = $value instanceof File;
                    break;
                case 'image':
                    $result = $value instanceof File && in_array($this->getImageType($value->getRealPath()), [
                                                                                                               1,
                                                                                                               2,
                                                                                                               3,
                                                                                                               6
                                                                                                           ]
                        );
                    break;
                case 'token':
                    $result = $this->token($value, '__token__', $data);
                    break;
                default:
                    if (isset(self::$type[$rule])) {
                        // 注册的验证规则
                        $result = call_user_func_array(self::$type[$rule], [$value]);
                    } else {
                        // 正则验证
                        $result = $this->regex($value, $rule);
                    }
            }
            return $result;
        }

        /**
         * 使用正则验证数据
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则 正则规则或者预定义正则名
         * @return mixed
         */
        protected function regex($value, $rule) {
            if (isset($this->regex[$rule])) {
                $rule = $this->regex[$rule];
            }
            if (0 !== strpos($rule, '/') && !preg_match('/\/[imsU]{0,4}$/', $rule)) {
                // 不是正则表达式则两端补上/
                $rule = '/^' . $rule . '$/';
            }
            return 1 === preg_match($rule, (string)$value);
        }

        /**
         * 使用filter_var方式验证
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function filter($value, $rule) {
            if (is_string($rule) && strpos($rule, ',')) {
                list($rule, $param) = explode(',', $rule);
            } elseif (is_array($rule)) {
                $param = isset($rule[1]) ? $rule[1] : null;
                $rule  = $rule[0];
            } else {
                $param = null;
            }
            return false !== filter_var($value, is_int($rule) ? $rule : filter_id($rule), $param);
        }

        protected function getImageType($image) {
            if (function_exists('exif_imagetype')) {
                return exif_imagetype($image);
            } else {
                $info = getimagesize($image);
                return $info[2];
            }
        }

        /**
         * 验证表单令牌
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function token($value, $rule, $data) {
            $rule = !empty($rule) ? $rule : '__token__';
            if (!isset($data[$rule]) || !Session::has($rule)) {
                // 令牌数据无效
                return false;
            }
            // 令牌验证
            if (isset($data[$rule]) && Session::get($rule) === $data[$rule]) {
                // 防止重复提交
                Session::delete($rule); // 验证完成销毁session
                return true;
            }
            // 开启TOKEN重置
            Session::delete($rule);
            return false;
        }

        /**
         * 验证是否为合格的域名或者IP 支持A，MX，NS，SOA，PTR，CNAME，AAAA，A6， SRV，NAPTR，TXT 或者 ANY类型
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function activeUrl($value, $rule) {
            if (!in_array($rule, [
                                   'A',
                                   'MX',
                                   'NS',
                                   'SOA',
                                   'PTR',
                                   'CNAME',
                                   'AAAA',
                                   'A6',
                                   'SRV',
                                   'NAPTR',
                                   'TXT',
                                   'ANY'
                               ]
            )
            ) {
                $rule = 'MX';
            }
            return checkdnsrr($value, $rule);
        }

        /**
         * 验证是否有效IP
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则 ipv4 ipv6
         * @return bool
         */
        protected function ip($value, $rule) {
            if (!in_array($rule, [
                                   'ipv4',
                                   'ipv6'
                               ]
            )
            ) {
                $rule = 'ipv4';
            }
            return $this->filter($value, [
                                           FILTER_VALIDATE_IP,
                                           'ipv6' == $rule ? FILTER_FLAG_IPV6 : FILTER_FLAG_IPV4
                                       ]
            );
        }

        /**
         * 验证上传文件后缀
         * @access protected
         * @param mixed $file 上传文件
         * @param mixed $rule 验证规则
         * @return bool
         */
        protected function fileExt($file, $rule) {
            if (!($file instanceof File)) {
                return false;
            }
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            if (is_array($file)) {
                foreach ($file as $item) {
                    if (!$item->checkExt($rule)) {
                        return false;
                    }
                }
                return true;
            } else {
                return $file->checkExt($rule);
            }
        }

        /**
         * 验证上传文件类型
         * @access protected
         * @param mixed $file 上传文件
         * @param mixed $rule 验证规则
         * @return bool
         */
        protected function fileMime($file, $rule) {
            if (!($file instanceof File)) {
                return false;
            }
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            if (is_array($file)) {
                foreach ($file as $item) {
                    if (!$item->checkMime($rule)) {
                        return false;
                    }
                }
                return true;
            } else {
                return $file->checkMime($rule);
            }
        }

        /**
         * 验证上传文件大小
         * @access protected
         * @param mixed $file 上传文件
         * @param mixed $rule 验证规则
         * @return bool
         */
        protected function fileSize($file, $rule) {
            if (!($file instanceof File)) {
                return false;
            }
            if (is_array($file)) {
                foreach ($file as $item) {
                    if (!$item->checkSize($rule)) {
                        return false;
                    }
                }
                return true;
            } else {
                return $file->checkSize($rule);
            }
        }

        /**
         * 验证图片的宽高及类型
         * @access protected
         * @param mixed $file 上传文件
         * @param mixed $rule 验证规则
         * @return bool
         */
        protected function image($file, $rule) {
            if (!($file instanceof File)) {
                return false;
            }
            if ($rule) {
                $rule = explode(',', $rule);
                list($width, $height, $type) = getimagesize($file->getRealPath());
                if (isset($rule[2])) {
                    $imageType = strtolower($rule[2]);
                    if ('jpeg' == $imageType) {
                        $imageType = 'jpg';
                    }
                    if (image_type_to_extension($type, false) != $imageType) {
                        return false;
                    }
                }
                list($w, $h) = $rule;
                return $w == $width && $h == $height;
            } else {
                return in_array($this->getImageType($file->getRealPath()), [
                                                                             1,
                                                                             2,
                                                                             3,
                                                                             6
                                                                         ]
                );
            }
        }

        /**
         * 验证请求类型
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function method($value, $rule) {
            $method = Request::instance()->method();
            return strtoupper($rule) == $method;
        }

        /**
         * 验证时间和日期是否符合指定格式
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function dateFormat($value, $rule) {
            $info = date_parse_from_format($rule, $value);
            return 0 == $info['warning_count'] && 0 == $info['error_count'];
        }

        /**
         * 验证是否唯一
         * @access protected
         * @param mixed  $value 字段值
         * @param mixed  $rule  验证规则 格式：数据表,字段名,排除ID,主键名
         * @param array  $data  数据
         * @param string $field 验证字段名
         * @return bool
         */
        protected function unique($value, $rule, $data, $field) {
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            if (false !== strpos($rule[0], '\\')) {
                // 指定模型类
                $db = new $rule[0];
            } else {
                try {
                    $db = Loader::model($rule[0]);
                } catch (ClassNotFoundException $e) {
                    $db = Db::name($rule[0]);
                }
            }
            $key = isset($rule[1]) ? $rule[1] : $field;
            if (strpos($key, '^')) {
                // 支持多个字段验证
                $fields = explode('^', $key);
                foreach ($fields as $key) {
                    $map[$key] = $data[$key];
                }
            } elseif (strpos($key, '=')) {
                parse_str($key, $map);
            } else {
                $map[$key] = $data[$field];
            }
            $pk = strval(isset($rule[3]) ? $rule[3] : $db->getPk());
            if (isset($rule[2])) {
                $map[$pk] = [
                    'neq',
                    $rule[2]
                ];
            } elseif (isset($data[$pk])) {
                $map[$pk] = [
                    'neq',
                    $data[$pk]
                ];
            }
            if ($db->where($map)->field($pk)->find()) {
                return false;
            }
            return true;
        }

        /**
         * 使用行为类验证
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return mixed
         */
        protected function behavior($value, $rule, $data) {
            return Hook::exec($rule, '', $data);
        }

        /**
         * 验证某个字段等于某个值的时候必须
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function requireIf($value, $rule, $data) {
            list($field, $val) = explode(',', $rule);
            if ($this->getDataValue($data, $field) == $val) {
                return !empty($value);
            } else {
                return true;
            }
        }

        /**
         * 通过回调方法验证某个字段是否必须
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function requireCallback($value, $rule, $data) {
            $result = call_user_func_array($rule, [
                                                    $value,
                                                    $data
                                                ]
            );
            if ($result) {
                return !empty($value);
            } else {
                return true;
            }
        }

        /**
         * 验证某个字段有值的情况下必须
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @param array $data  数据
         * @return bool
         */
        protected function requireWith($value, $rule, $data) {
            $val = $this->getDataValue($data, $rule);
            if (!empty($val)) {
                return !empty($value);
            } else {
                return true;
            }
        }

        /**
         * 验证是否在范围内
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function in($value, $rule) {
            return in_array($value, is_array($rule) ? $rule : explode(',', $rule));
        }

        /**
         * 验证是否不在某个范围
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function notIn($value, $rule) {
            return !in_array($value, is_array($rule) ? $rule : explode(',', $rule));
        }

        /**
         * between验证数据
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function between($value, $rule) {
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            list($min, $max) = $rule;
            return $value >= $min && $value <= $max;
        }

        /**
         * 使用notbetween验证数据
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function notBetween($value, $rule) {
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            list($min, $max) = $rule;
            return $value < $min || $value > $max;
        }

        /**
         * 验证数据长度
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function length($value, $rule) {
            if (is_array($value)) {
                $length = count($value);
            } elseif ($value instanceof File) {
                $length = $value->getSize();
            } else {
                $length = mb_strlen((string)$value);
            }
            if (strpos($rule, ',')) {
                // 长度区间
                list($min, $max) = explode(',', $rule);
                return $length >= $min && $length <= $max;
            } else {
                // 指定长度
                return $length == $rule;
            }
        }

        /**
         * 验证数据最大长度
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function max($value, $rule) {
            if (is_array($value)) {
                $length = count($value);
            } elseif ($value instanceof File) {
                $length = $value->getSize();
            } else {
                $length = mb_strlen((string)$value);
            }
            return $length <= $rule;
        }

        /**
         * 验证数据最小长度
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function min($value, $rule) {
            if (is_array($value)) {
                $length = count($value);
            } elseif ($value instanceof File) {
                $length = $value->getSize();
            } else {
                $length = mb_strlen((string)$value);
            }
            return $length >= $rule;
        }

        // 获取错误信息

        /**
         * 验证日期
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function after($value, $rule) {
            return strtotime($value) >= strtotime($rule);
        }

        /**
         * 验证日期
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function before($value, $rule) {
            return strtotime($value) <= strtotime($rule);
        }

        /**
         * 验证有效期
         * @access protected
         * @param mixed $value 字段值
         * @param mixed $rule  验证规则
         * @return bool
         */
        protected function expire($value, $rule) {
            if (is_string($rule)) {
                $rule = explode(',', $rule);
            }
            list($start, $end) = $rule;
            if (!is_numeric($start)) {
                $start = strtotime($start);
            }
            if (!is_numeric($end)) {
                $end = strtotime($end);
            }
            return $_SERVER['REQUEST_TIME'] >= $start && $_SERVER['REQUEST_TIME'] <= $end;
        }

        /**
         * 验证IP许可
         * @access protected
         * @param string $value 字段值
         * @param mixed  $rule  验证规则
         * @return mixed
         */
        protected function allowIp($value, $rule) {
            return in_array($_SERVER['REMOTE_ADDR'], is_array($rule) ? $rule : explode(',', $rule));
        }

        /**
         * 验证IP禁用
         * @access protected
         * @param string $value 字段值
         * @param mixed  $rule  验证规则
         * @return mixed
         */
        protected function denyIp($value, $rule) {
            return !in_array($_SERVER['REMOTE_ADDR'], is_array($rule) ? $rule : explode(',', $rule));
        }
    }
